/*package com.qhgrain.app.controller;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

import javax.annotation.Resource;

import org.apache.commons.collections.CollectionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import com.paas.bpm.external.api.BpmApiResult;
import com.paas.common.util.ExceptionUtil;
import com.paas.common.web.ResultMessage;
import com.paas.model.sys.Organization;
import com.paas.model.sys.Role;
import com.paas.model.sys.User;
import com.paas.service.sys.IOrganizationService;
import com.paas.service.sys.IRoleService;
import com.paas.service.sys.IUserService;
import com.pass.service.synchronize.SynchronizeDataService;

*//***
 * 
  * @Description: TODO数据同步方案,用户信息已增量的方式将IAM的部门和用户信息同步到bpm中 
  * @Copyright: Copyright (c) 2015-2020
  *	
 *//*

@Controller
@RequestMapping("/api/paas/bpm/bpmSynchronize")
public class SynchronizeDataController {
	
	@Resource
	private IUserService userService;
	@Resource
	private IOrganizationService organizationService;
	@Resource
	private IRoleService roleService;
	@Resource
	private SynchronizeDataService synchronizeDataService;
	
	protected final Logger logger = LoggerFactory.getLogger(SynchronizeDataController.class);
	
	*//**
	 * 同步部门信息的接口
	 * @return
	 *//*
	@RequestMapping(value = "/orgData")
	public @ResponseBody BpmApiResult synchronizeORGData(){
		BpmApiResult result = new BpmApiResult();
		try {
			logger.info("通过rest接口开始从IAM中获取部门信息...");
			//返回全部部门信息
			List<Organization> organizations = synchronizeDataService.getOrgs();
			if (organizations == null || organizations.size() == 0) {
				result.setResult(ResultMessage.Fail);
				result.setMessage("获取部门失败，部门个数为:"+organizations.size());
				return result;
			}
			//日志中统计一下查询获取多少部门
			logger.info("发现"+organizations.size()+"个部门.");
			if(CollectionUtils.isNotEmpty(organizations)){
				logger.info("同步IAM部门信息开始...");
				// 记录错误条数，以及失败的对象
				List<Organization> errorOrgs = new LinkedList<Organization>();
				//循环遍历查询到的organizations列表数据
				for (Iterator<Organization> iterator = organizations.iterator(); iterator.hasNext();) {
					Organization organization = iterator.next();
					try {
						//根据用户的id查询当前数据库中是否存在，如果存在则调用update方法；否则调用add方法
						Organization dbOrganization = organizationService.getById(organization.getOrgId());
						if (dbOrganization != null) {
							//如果数据库中已存在该数据则把数据进行更新
							organizationService.update(organization);
						}else{
							//将users实体对象保存到数据库中
							organizationService.add(organization);
						}
					} catch (Exception e) {
						//如果保存过程中出现异常则视为报错失败，将报错失败的用户记录
						errorOrgs.add(organization);
						e.printStackTrace();
					}
				}
				String message = "同步IAM部门信息已完成,统计信息:[成功条数:" + (+organizations.size()-errorOrgs.size()) + "条,失败条数:" + errorOrgs.size() + "条,详细失败部门:" + errorOrgs + "].";
				result.setResult(ResultMessage.Success);
				result.setMessage(message);
				logger.info(message);
			}
		} catch (Exception e) {
			//将错误信息打印到控制台，并记录到日志中
			e.printStackTrace();
			logger.error("同步IAM部门信息发生异常.", e);
			result.setResult(ResultMessage.Fail);
			result.setMessage(ExceptionUtil.getExceptionMessage(e));
		}
		return result;
	}
	*//**************************************** 同步群组信息  ********************************************//*
	
	*//**
	 * 同步群组信息的接口
	 * 
	 * @return
	 *//*
	@RequestMapping(value = "/roleData")
	@ResponseBody
	public BpmApiResult synchronizeROLEData() {
		BpmApiResult result = new BpmApiResult();
		List<Role> roles = synchronizeDataService.getRoles();
		if (roles == null || roles.size() == 0) {
			result.setResult(ResultMessage.Fail);
			result.setMessage("获取群组失败，群组个数为:"+roles.size());
			return result;
		}
		try {
			// 日志中统计一下查询获取多少群组
			logger.info("发现" + roles.size() + "个群组.");
			if (CollectionUtils.isNotEmpty(roles)) {
				logger.info("同步IAM群组信息开始...");
				// 记录错误条数，以及失败的对象
				List<Role> errorRoles = new LinkedList<Role>();
				// 循环遍历查询到的users列表数据
				for (Iterator<Role> iterator = roles.iterator(); iterator.hasNext();) {
					Role role = iterator.next();
					try {
						// 根据用户的id查询当前数据库中是否存在，如果存在则调用update方法；否则调用add方法
						Role dbRole = roleService.getById(role.getRoleId());
						if (dbRole != null) {
							// 如果数据库中已存在该数据则把数据进行更新
							roleService.updateRole(role);
						} else {
							// 将role实体对象保存到数据库中
							roleService.addRole(role);
						}
					} catch (Exception e) {
						e.printStackTrace();
						// 如果保存过程中出现异常则视为报错失败，将报错失败的群组记录
						errorRoles.add(role);
					}
				}
				String message = "同步IAM群组信息已完成,统计信息:[成功条数:" + (+roles.size() - errorRoles.size()) + "条,失败条数:"
						+ errorRoles.size() + "条,详细失败群组:" + errorRoles + "].";
				result.setResult(ResultMessage.Success);
				result.setMessage(message);
				logger.info(message);
			}
		} catch (Exception e) {
			// 将错误信息打印到控制台，并记录到日志中
			e.printStackTrace();
			logger.error("同步IAM群组信息发生异常.", e);
			result.setResult(ResultMessage.Fail);
			result.setMessage("同步群组数据发生异常，请查看服务器日志信息");
		}
		return result;
	}
	
	*//**************************************** 同步用户信息  ********************************************//*
	
	*//**
	 * 同步部门信息的接口
	 * @return
	 *//*
	@RequestMapping(value = "/userData")
	public @ResponseBody BpmApiResult synchronizeUSERData(){
		BpmApiResult result = new BpmApiResult();
		try {
			logger.info("通过rest接口开始从IAM中获取用户信息...");
			//返回全部用户信息
			List<User> users = synchronizeDataService.getUsers();
			if (users == null || users.size() == 0) {
				result.setResult(ResultMessage.Fail);
				result.setMessage("获取用户失败，用户个数为:"+users.size());
				return result;
			}
			//日志中统计一下查询获取多少用户
			logger.info("发现"+users.size()+"个用户.");
			if(CollectionUtils.isNotEmpty(users)){
				logger.info("同步IAM用户信息开始...");
				// 记录错误条数，以及失败的对象
				List<User> errorUsers = new LinkedList<User>();
				//循环遍历查询到的users列表数据
				for (Iterator<User> iterator = users.iterator(); iterator.hasNext();) {
					User user = iterator.next();
					try {
						//根据用户的id查询当前数据库中是否存在，如果存在则调用update方法；否则调用add方法
						User dbUser = userService.getByAccount(user.getAccount());
						if (dbUser != null) {
							//如果数据库中已存在该数据则把数据进行更新
							userService.updateUser(user);
						}else{
							//将users实体对象保存到数据库中
							userService.addUser(user);
						}
					} catch (Exception e) {
						e.printStackTrace();
						//如果保存过程中出现异常则视为报错失败，将报错失败的用户记录
						errorUsers.add(user);
					}
				}
				String message = "同步IAM用户信息已完成,统计信息:[成功条数:" + (+users.size()-errorUsers.size()) + "条,失败条数:" + errorUsers.size() + "条,详细失败人员:" + errorUsers + "].";
				result.setResult(ResultMessage.Success);
				result.setMessage(message);
				logger.info(message);
			}
		} catch (Exception e) {
			//将错误信息打印到控制台，并记录到日志中
			e.printStackTrace();
			logger.error("同步IAM用户信息发生异常.", e);
			result.setResult(ResultMessage.Fail);
			result.setMessage(ExceptionUtil.getExceptionMessage(e));
		}
		return result;
	}
}
*/